package pc

import (
	. "chess_platform/internal/common"
	"chess_platform/models/client"
	"chess_platform/models/pc"
	"fmt"
	"time"
)

//[pc]operation:运维管理
type OperationController struct {
	GrantController
}

func (b *OperationController) URLMapping() {
	//server:服务器设置
	b.Mapping("NewServer", b.NewServer)
	b.Mapping("UpdateServer", b.UpdateServer)
	b.Mapping("ServerInfo", b.ServerInfo)
	b.Mapping("DeleteServer", b.DeleteServer)
	b.Mapping("ListServer", b.ListServer)
	b.Mapping("GetCurrentServerGroup", b.GetCurrentServerGroup)
	b.Mapping("SetCurrentServerGroup", b.SetCurrentServerGroup)

	//platform:平台服务器设置
	b.Mapping("NewPlatform", b.NewPlatform)
	b.Mapping("UpdatePlatform", b.UpdatePlatform)
	b.Mapping("PlatformInfo", b.PlatformInfo)
	b.Mapping("DeletePlatform", b.DeletePlatform)
	b.Mapping("ListPlatform", b.ListPlatform)

	//card-test:测试配牌
	b.Mapping("NewCardTest", b.NewCardTest)
	b.Mapping("UpdateCardTest", b.UpdateCardTest)
	b.Mapping("UpdateCardTestStatus", b.UpdateCardTestStatus)
	b.Mapping("DeleteCardTest", b.DeleteCardTest)
	b.Mapping("ListCardTest", b.ListCardTest)
	b.Mapping("CardTestInfo", b.CardTestInfo)

	//system:系统设置
	b.Mapping("NewSystemConf", b.NewSystemConf)
	b.Mapping("UpdateSystemConf", b.UpdateSystemConf)
	b.Mapping("SystemConfInfo", b.SystemConfInfo)
	b.Mapping("DeleteSystemConf", b.DeleteSystemConf)
	b.Mapping("ListSystemConf", b.ListSystemConf)

	//app:版本发布
	b.Mapping("NewApp", b.NewApp)
	b.Mapping("UpdateApp", b.UpdateApp)
	b.Mapping("UpdateAppStatus", b.UpdateAppStatus)
	b.Mapping("DeleteApp", b.DeleteApp)
	b.Mapping("AppInfo", b.AppInfo)
	b.Mapping("ListApp", b.ListApp)

	//params:各种规则参数
	b.Mapping("NewRule", b.NewRule)
	b.Mapping("UpdateRule", b.UpdateRule)
	b.Mapping("DeleteRule", b.DeleteRule)
	b.Mapping("ListRule", b.ListRule)

}

// @Title 新建服务器配置
// @Description 新建服务器配置
// @Param   svrid        body   int        true        "服务器ID"
// @Param   name         body   string     true        "服务器名字"
// @Param   group        body   int        true        "服务器组"
// @Param   svr_type     body   int        true        "服务器类型(1大厅，2游戏服)"
// @Param   game_type    body   int        true        "游戏类型"
// @Param   game_subtype body   int        true        "游戏子类型,1普通，2私人，3比赛"
// @Param   play_types   body   string     true        "玩法"
// @Param   svrip        body   string     false       "服务器IP"
// @Param   svrport      body   int        true        "服务器端口"
// @Param   svrlanport   body   int        true        "服务器对服务器端口"
// @Param   phpport      body   int        true        "web连接端口"
// @Param   state        body   int        true        "服务器状态,服务器状态,1-正常，0-异常"
// @Success 0 {string}  状态码
// @router /server/new-server [post]
func (b *OperationController) NewServer() {
	var p Server
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.SvrId, "svrid").Message("服务器ID不能为0")
	b.Valid.Required(p.Name, "name").Message("服务器名字不能为空")
	//b.Valid.Range(p.SvrType, 1, 2, "svr_type").Message("服务器类型(1大厅，2游戏服)")
	//b.Valid.IP(p.SvrIp, "svrip").Message("服务器IP不能为空")
	//b.Valid.Required(p.SvrPort, "svrport").Message("服务器端口不能为0")
	//b.Valid.Required(p.SvrLanPort, "svrlanport").Message("服务器对服务器端口不能为0")
	//b.Valid.Required(p.PhpPort, "phpport").Message("web连接端口不能为0")
	b.Valid.Range(p.State, 0, 1, "state").Message("服务器状态取值为0-1")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"svrid":        p.SvrId,
		"name":         p.Name,
		"group":        p.Group,
		"svr_type":     p.SvrType,
		"game_type":    p.GameType,
		"game_subtype": p.GameSubType,
		"play_types":   p.PlayTypes,
		"svrip":        p.SvrIp,
		"svrport":      p.SvrPort,
		"svrlanport":   p.SvrLanPort,
		"phpport":      p.PhpPort,
		"state":        p.State,
	}
	_, err := pc.NewServer(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	pc.MakeServerConfigFile()
	b.NewLog(LogConfig, OpNew, "新建服务器", data)
}

// @Title 更新服务器配置
// @Description 更新服务器配置
// @Param   svrid        body   int        true        "id"
// @Param   name         body   string     true        "服务器名字"
// @Param   group        body   int        true        "服务器组"
// @Param   svr_type     body   int        true        "服务器类型(1大厅，2游戏服)"
// @Param   game_type    body   int        true        "游戏类型"
// @Param   game_subtype body   int        true        "游戏子类型,1普通，2私人，3比赛"
// @Param   play_types   body   string     true        "玩法"
// @Param   svrip        body   string     false       "服务器IP"
// @Param   svrport      body   int        true        "服务器端口"
// @Param   svrlanport   body   int        true        "服务器对服务器端口"
// @Param   phpport      body   int        true        "web连接端口"
// @Param   state        body   int        true        "服务器状态,服务器状态,1-正常，0-异常"
// @Success 0 {string}  状态码
// @router /server/update-server [post]
func (b *OperationController) UpdateServer() {
	var p Server
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.SvrId, "svrid").Message("服务器ID不能为0")
	b.Valid.Required(p.Name, "name").Message("服务器名字不能为空")
	//b.Valid.Range(p.SvrType, 1, 2, "svr_type").Message("服务器类型(1大厅，2游戏服)")
	//b.Valid.IP(p.SvrIp, "svrip").Message("服务器IP不能为空")
	//b.Valid.Required(p.SvrPort, "svrport").Message("服务器端口不能为0")
	//b.Valid.Required(p.SvrLanPort, "svrlanport").Message("服务器对服务器端口不能为0")
	//b.Valid.Required(p.PhpPort, "phpport").Message("web连接端口不能为0")
	b.Valid.Range(p.State, 0, 1, "state").Message("服务器状态取值为0-1")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"svrid":        p.SvrId,
		"name":         p.Name,
		"group":        p.Group,
		"svr_type":     p.SvrType,
		"game_type":    p.GameType,
		"game_subtype": p.GameSubType,
		"play_types":   p.PlayTypes,
		"svrip":        p.SvrIp,
		"svrport":      p.SvrPort,
		"svrlanport":   p.SvrLanPort,
		"phpport":      p.PhpPort,
		"state":        p.State,
	}
	err := pc.UpdateServer(data, p.SvrId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	pc.MakeServerConfigFile()
	msg := fmt.Sprintf("更新服务器(名字:%v)", p.Name)
	b.NewLog(LogConfig, OpUpdate, msg, data)
}

// @Title 获取服务器信息
// @Description 获取服务器信息
// @Param   svrid  body    int     true      "id"
// @Success 0 {object} common.Server 服务器信息列表
// @router /server/server-info [post]
func (b *OperationController) ServerInfo() {
	type Params struct {
		SvrId int64 `json:"svrid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	server, err := pc.ServerInfoById(p.SvrId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = server
	b.ResponseSuccess()
}

// @Title 删除服务器
// @Description 删除服务器
// @Param   svrid  body    int     true      "服务器id"
// @Success 0 {string} 状态码
// @router /server/delete-server [post]
func (b *OperationController) DeleteServer() {
	type Params struct {
		SvrId int64 `json:"svrid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	server, err := pc.DeleteServer(p.SvrId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = server
	b.ResponseSuccess()
}

// @Title 获取服务器配置列表
// @Description  获取服务器配置列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Server 服务器信息列表
// @router /server/list-server  [post]
func (b *OperationController) ListServer() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	rc, count, err := pc.ListServer(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = rc
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 获取正在生效的服务组
// @Description 获取正在生效的服务组
// @Success 0 {string}  正在生效的服务组
// @router /server/get-current-server-group [post]
func (b *OperationController) GetCurrentServerGroup() {
	b.Res.Data = client.GetCurSvrGroup()
	b.ResponseSuccess()
}

// @Title 切换生效的服务组
// @Description 切换生效的服务组
// @Param   group  body   int     true       "服务器组"
// @Success 0 {string}  获取正在生效的服务组
// @router /server/set-current-server-group [post]
func (b *OperationController) SetCurrentServerGroup() {
	type Params struct {
		Group int64 `json:"group"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	client.SetCurSvrGroup(p.Group)
	b.ResponseSuccess("切服成功")
}

//--------------------平台服配置------------------------
// @Title 新建平台服务器配置
// @Description 新建平台服务器配置
// @Param   id           body   int        true        "服务器ID"
// @Param   name         body   string     true        "服务器名字"
// @Param   type         body   int        true        "服务器类型,1-pc后台管理系统,2-代理助手系统,3-游戏客户端系统,4-合伙人系统,5-合伙人后台系统"
// @Param   ip           body   string     true        "服务器IP"
// @Param   http_port    body   int        true        "服务器端口"
// @Param   admin_port   body   int        true        "服务器监控端口"
// @Param   status       body   int        true        "服务器状态,1-正常,2-停服,3-异常"
// @Param   execute_task body   int        true        "服务器是否执行定时任务,1-执行,0-不执行"
// @Success 0 {string}  状态码
// @router /platform/new-platform [post]
func (b *OperationController) NewPlatform() {
	var p Platform
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("服务器ID不能为0")
	b.Valid.Required(p.Name, "name").Message("服务器名字不能为空")
	b.Valid.Range(p.Type, 1, 5, "type").Message("服务器类型,1-pc后台管理系统,2-代理助手系统,3-游戏客户端系统,4-合伙人系统,5-合伙人后台系统")
	b.Valid.Required(p.IP, "ip").Message("服务器IP不能为空")
	b.Valid.Required(p.HttpPort, "port").Message("服务器端口不能为0")
	b.Valid.Required(p.AdminPort, "port").Message("服务器监控端口不能为0")
	b.Valid.Range(p.Status, 1, 3, "status").Message("服务器状态,1-正常,2-停服,3-异常")
	b.Valid.Range(p.ExecuteTask, 0, 1, "execute_task").Message("服务器是否执行定时任务,1-执行,0-不执行")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"id":           p.Id,
		"name":         p.Name,
		"type":         p.Type,
		"ip":           p.IP,
		"http_port":    p.HttpPort,
		"admin_port":   p.AdminPort,
		"status":       p.Status,
		"execute_task": p.ExecuteTask,
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewPlatform(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	b.NewLog(LogConfig, OpNew, "新建平台服务器", data)
}

// @Title 更新平台服务器配置
// @Description 更新平台服务器配置
// @Param   id           body   int        true        "服务器ID"
// @Param   name         body   string     true        "服务器名字"
// @Param   type         body   int        true        "服务器类型,1-pc后台管理系统,2-代理助手系统,3-游戏客户端系统,4-合伙人系统,5-合伙人后台系统"
// @Param   ip           body   string     true        "服务器IP"
// @Param   http_port    body   int        true        "服务器端口"
// @Param   admin_port   body   int        true        "服务器监控端口"
// @Param   status       body   int        true        "服务器状态,1-正常,2-停服,3-异常"
// @Param   execute_task body   int        true        "服务器是否执行定时任务,1-执行,0-不执行"
// @Success 0 {string}  状态码
// @router /platform/update-platform [post]
func (b *OperationController) UpdatePlatform() {
	var p Platform
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("服务器ID不能为0")
	b.Valid.Required(p.Name, "name").Message("服务器名字不能为空")
	b.Valid.Range(p.Type, 1, 5, "type").Message("服务器类型,1-pc后台管理系统,2-代理助手系统,3-游戏客户端系统,4-合伙人系统,5-合伙人后台系统")
	b.Valid.Required(p.IP, "ip").Message("服务器IP不能为空")
	b.Valid.Required(p.HttpPort, "port").Message("服务器端口不能为0")
	b.Valid.Required(p.AdminPort, "port").Message("服务器监控端口不能为0")
	b.Valid.Range(p.Status, 1, 3, "status").Message("服务器状态,1-正常,2-停服,3-异常")
	b.Valid.Range(p.ExecuteTask, 0, 1, "execute_task").Message("服务器是否执行定时任务,1-执行,0-不执行")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"id":           p.Id,
		"name":         p.Name,
		"type":         p.Type,
		"ip":           p.IP,
		"http_port":    p.HttpPort,
		"admin_port":   p.AdminPort,
		"status":       p.Status,
		"execute_task": p.ExecuteTask,
		"modify_time":  time.Now().Unix(),
	}
	err := pc.UpdatePlatform(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	errs := SendMsgToInitPlatformConf()
	if len(errs) > 0 {
		LogPc.Error(b.SystemError(errs...))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新平台服务器(名字:%v)", p.Name)
	b.NewLog(LogConfig, OpUpdate, msg, data)
}

// @Title 获取平台服务器信息
// @Description 获取平台服务器信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.Platform 服务器信息
// @router /platform/platform-info [post]
func (b *OperationController) PlatformInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	server, err := pc.PlatformInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = server
	b.ResponseSuccess()
}

// @Title 删除服务器
// @Description 删除服务器
// @Param   id  body    int     true      "服务器id"
// @Success 0 {string} 状态码
// @router /platform/delete-platform [post]
func (b *OperationController) DeletePlatform() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	server, err := pc.DeletePlatform(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = server
	b.ResponseSuccess()
}

// @Title 获取平台服务器配置列表
// @Description  获取平台服务器配置列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Platform 平台服务器信息列表
// @router /platform/list-platform [post]
func (b *OperationController) ListPlatform() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	rc, count, err := pc.ListPlatform(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = rc
	b.Res.Count = count
	b.ResponseSuccess()
}

//---------------------------------配牌----------------------

// @Title 新建配置版型
// @Description 新建配置版型
// @Param   game_type         body   int        true        "game_type"
// @Param   play_type         body   int        true        "play_type"
// @Param   cards             body   string     true        "牌型"
// @Param   remark            body   string     false       "备注"
// @Param   status            body   int        false       "0-不生效,1-生效"
// @Success 0 {string}  状态码
// @router /card-test/new-card-test [post]
func (b *OperationController) NewCardTest() {
	var p CardTest
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.GameType, "game_type").Message("game_type不能为空")
	b.Valid.Required(p.PlayType, "play_type").Message("play_type不能为空")
	b.Valid.Required(p.Cards, "cards").Message("牌型不能为空")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"game_type": p.GameType,
		"play_type": p.PlayType,
		"cards":     p.Cards,
		"remark":    p.Remark,
		"status":    p.Status,
	}
	_, err := pc.NewCardTest(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

}

// @Title 更新配置版型
// @Description 更新配置版型
// @Param   id                body   int        true        "id"
// @Param   game_type         body   int        true        "game_type"
// @Param   play_type         body   int        true        "play_type"
// @Param   cards             body   string     true        "牌型"
// @Param   remark            body   string     false       "备注"
// @Success 0 {string}  状态码
// @router /card-test/update-card-test [post]
func (b *OperationController) UpdateCardTest() {
	var p CardTest
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为空")
	b.Valid.Required(p.GameType, "game_type").Message("game_type不能为空")
	b.Valid.Required(p.PlayType, "play_type").Message("play_type不能为空")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"game_type": p.GameType,
		"play_type": p.PlayType,
		"cards":     p.Cards,
		"remark":    p.Remark,
	}
	err := pc.UpdateCardTest(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
}

// @Title 更新配置版型状态
// @Description 更新配置版型状态
// @Param   id                body   int        true        "id"
// @Param   status            body   int        false       "0-不生效,1-生效"
// @Success 0 {string}  状态码
// @router /card-test/update-card-test-status [post]
func (b *OperationController) UpdateCardTestStatus() {
	type Params struct {
		Id     int64 `json:"id" valid:"Required"`
		Status int64 `json:"status" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	data := map[string]interface{}{
		"status": p.Status,
	}
	err := pc.UpdateCardTest(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
}

// @Title 牌型信息
// @Description 牌型信息
// @Param   id    body   int        true        "id"
// @Success 0 {string}  common.CardTest
// @router /card-test/card-test-info [post]
func (b *OperationController) CardTestInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.CardTestInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title 牌型列表
// @Description 牌型列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.CardTest
// @Failure 399
// @router /card-test/list-card-test [post]
func (b *OperationController) ListCardTest() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListCardTest(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 删除牌型
// @Description 删除牌型
// @Param   id body   int        true        "id"
// @Success 0 {string}  状态码
// @router /card-test/delete-card-test [post]
func (b *OperationController) DeleteCardTest() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteCardTest(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
}

// @Title 新建系统配置
// @Description 新建配置版型
// @Param   sckey             body   string        true        "key"
// @Param   value             body   string        true        "值"
// @Param   mean              body   string        false       "意义"
// @Param   value_type        body   string        true        "值的类型,string,int,json,json[]"
// @Success 0 {string}  状态码
// @router /system/new-system-conf [post]
func (b *OperationController) NewSystemConf() {
	var p SystemConf
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Sckey, "sckey").Message("键不能为空")
	b.Valid.Required(p.Value, "value").Message("值不能为空")
	b.Valid.Required(p.ValueType, "value_type").Message("值的类型,string,int,json,json[]")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"sckey":       p.Sckey,
		"value":       p.Value,
		"mean":        p.Mean,
		"value_type":  p.ValueType,
		"modify_time": time.Now().Unix(),
		"create_time": time.Now().Unix(),
	}
	_, err := pc.NewSystemConf(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("添加新系统配置")
	b.NewLog(LogSystem, OpNew, msg, data)
}

// @Title 更新系统配置
// @Description 更新系统配置
// @Param   id                body   int           true        "id"
// @Param   sckey             body   string        true        "key"
// @Param   value             body   string        true        "值"
// @Param   mean              body   string        false       "意义"
// @Param   value_type        body   string        true        "值的类型,string,int,json,json[]"
// @Success 0 {string}  状态码
// @router /system/update-system-conf [post]
func (b *OperationController) UpdateSystemConf() {
	var p SystemConf
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为空")
	b.Valid.Required(p.Sckey, "sckey").Message("键不能为空")
	b.Valid.Required(p.Value, "value").Message("值不能为空")
	b.Valid.Required(p.ValueType, "value_type").Message("值的类型,string,int,json,json[]")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"sckey":       p.Sckey,
		"value":       p.Value,
		"mean":        p.Mean,
		"value_type":  p.ValueType,
		"modify_time": time.Now().Unix(),
	}
	err := pc.UpdateSystemConf(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	//通知游戏服务器重新加载配置文件
	if !client.NotifyReloadConfig() {
		LogPc.Error("游戏服务器返回失败,通知加载系统配置文件失败")
		b.ResponseFail("游戏服务器返回失败,通知加载系统配置文件失败")
		return
	}
	errs := SendMsgToReloadConf()
	if len(errs) > 0 {
		LogPc.Error(b.SystemError(errs...))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新系统配置")
	b.NewLog(LogSystem, OpUpdate, msg, data)
}

// @Title 系统配置信息
// @Description 系统配置信息
// @Param   id    body   int        true        "id"
// @Success 0 {string}  common.SystemConf
// @router /system/system-conf-info [post]
func (b *OperationController) SystemConfInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.SystemConfInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title 系统配置列表
// @Description 系统配置列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.SystemConf
// @Failure 399
// @router /system/list-system-conf [post]
func (b *OperationController) ListSystemConf() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListSystemConf(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 删除系统配置
// @Description 删除系统配置
// @Param   id body   int        true        "id"
// @Success 0 {string}  状态码
// @router /system/delete-system-conf [post]
func (b *OperationController) DeleteSystemConf() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteSystemConf(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除系统配置(ID:%v)", p.Id)
	b.NewLog(LogSystem, OpUpdate, msg, map[string]interface{}{})
}

// @Title 添加APP新版本游戏
// @Description 添加APP新版本游戏
// @Param   type              body   int        true       "APP分类,1-安卓版本,2-苹果版本"
// @Param   download_url      body   string     true       "APP下载地址"
// @Param   change_log        body   string     false      "版本变动说明"
// @Param   version           body   string     true       "版本号"
// @Success 0 {string}  状态码
// @router /app/new-app [post]
func (b *OperationController) NewApp() {
	var p APP
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Range(p.Type, 1, 2, "type").Message("APP分类,1-安卓版本,2-苹果版本")
	b.Valid.Required(p.DownloadUrl, "download_url").Message("APP下载地址不能为空")
	b.Valid.Required(p.Version, "version").Message("APP版本号不能为空")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"type":         p.Type,
		"download_url": p.DownloadUrl,
		"change_log":   p.ChangeLog,
		"version":      p.Version,
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewApp(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("添加新版本APP")
	b.NewLog(LogOperation, OpNew, msg, data)
}

// @Title 更新APP新版本游戏
// @Description 更新APP新版本游戏
// @Param   id                body   int        true       "id"
// @Param   type              body   int        true       "APP分类,1-安卓版本,2-苹果版本"
// @Param   download_url      body   string     true       "APP下载地址"
// @Param   change_log        body   string     false      "版本变动说明"
// @Param   version           body   string     true       "版本号"
// @Success 0 {string}  状态码
// @router /app/update-app [post]
func (b *OperationController) UpdateApp() {
	var p APP
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("ID不能为0")
	b.Valid.Range(p.Type, 1, 2, "type").Message("APP分类,1-安卓版本,2-苹果版本")
	b.Valid.Required(p.DownloadUrl, "download_url").Message("APP下载地址不能为空")
	b.Valid.Required(p.Version, "version").Message("APP版本号不能为空")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"type":         p.Type,
		"download_url": p.DownloadUrl,
		"change_log":   p.ChangeLog,
		"version":      p.Version,
		"modify_time":  time.Now().Unix(),
	}
	_, err := pc.UpdateApp(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("更新版本APP(ID:%v)", p.Id)
	b.NewLog(LogOperation, OpUpdate, msg, data)
}

// @Title 更新APP新版本游戏
// @Description 更新APP新版本游戏
// @Param   id                body   int        true       "id"
// @Param   status            body   int        true       "此版本的APP, 1-上架，0-下架
// @Success 0 {string}  状态码
// @router /app/update-app-status [post]
func (b *OperationController) UpdateAppStatus() {
	type Params struct {
		Id     int64 `json:"id" valid:"Required"`
		Status int64 `json:"status" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"status": p.Status,
	}
	_, err := pc.UpdateApp(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("更新版本APP为上下线(ID:%v)", p.Id)
	b.NewLog(LogOperation, OpUpdate, msg, data)
}

// @Title 删除APP
// @Description 删除APP
// @Param   id         body   int        true        "id"
// @Success 0 {string}  状态码
// @router /app/delete-app [post]
func (b *OperationController) DeleteApp() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	pc.DeleteApp(p.Id)
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除APP(ID:%v)", p.Id)
	b.NewLog(LogOperation, OpDelete, msg, map[string]interface{}{})
}

// @Title 获取APP信息
// @Description 获取APP信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.APP  APP信息
// @router /app/app-info [post]
func (b *OperationController) AppInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	data, err := pc.AppInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title APP列表
// @Description APP列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.APP 游戏列表
// @router /app/list-app [post]
func (b *OperationController) ListApp() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListApp(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

//-----------------------------------参数设置-----------------------------------------------------------
// @Title 新增各种规则(提现，进货价,手续费,税费,等等)
// @Description 新增各种规则(提现，进货价,手续费,税费,等等)
// @Param   type         body   int        true        "类型"
// @Param   name         body   string     true        "参数名字"
// @Param   amount       body   int        true        "值"
// @Param   scale        body   int        true        "比例"
// @Param   unit         body   string     true        "单位,元,张之类的"
// @Success 0 {string}  状态码
// @router /params/new-rule [post]
func (b *OperationController) NewRule() {
	type Params struct {
		Type   int64  `json:"type"`
		Name   string `json:"name"`
		Amount int64  `json:"amount"`
		Scale  int64  `json:"scale"`
		Unit   string `json:"unit"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Type, "type").Message("请输入类型,取值范围大于等1整数")
	b.Valid.Required(p.Name, "name").Message("请输入参数名字")
	b.Valid.Required(p.Amount, "amount").Message("请输入数值")
	b.Valid.Required(p.Scale, "scale").Message("请输入比例")
	b.Valid.Required(p.Unit, "unit").Message("请输入单位")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"type":   p.Type,
		"name":   p.Name,
		"scale":  p.Scale,
		"unit":   p.Unit,
		"amount": p.Amount,
	}
	_, err := pc.NewRule(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("新增各种规则")
	b.NewLog(LogFinance, OpNew, msg, data)

}

// @Title 更新各种规则(提现，进货价,手续费,税费,等等)
// @Description 更新各种规则(提现，进货价,手续费,税费,等等)
// @Param   type         body   int        true        "类型"
// @Param   name         body   string     true        "参数名字"
// @Param   amount       body   int        true        "值"
// @Param   scale        body   int        true        "比例"
// @Param   unit         body   string     true        "单位,元,张之类的"
// @Success 0 {string}  状态码
// @router /params/update-rule [post]
func (b *OperationController) UpdateRule() {
	type Params struct {
		Type   int64  `json:"type"`
		Name   string `json:"name"`
		Amount int64  `json:"amount"`
		Scale  int64  `json:"scale"`
		Unit   string `json:"unit"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Type, "type").Message("请输入类型")
	b.Valid.Required(p.Name, "name").Message("请输入参数名字")
	b.Valid.Required(p.Amount, "amount").Message("请输入数值")
	b.Valid.Required(p.Scale, "scale").Message("请输入比例")
	b.Valid.Required(p.Unit, "unit").Message("请输入单位")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"name":   p.Name,
		"scale":  p.Scale,
		"unit":   p.Unit,
		"amount": p.Amount,
	}

	_, err := pc.UpdateRule(data, p.Type)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	//更新了就更新到缓存里,这样能实时生效
	//id应该改成type的
	Key := fmt.Sprintf("%v%v", KeyRuleType, p.Type)
	SetCache(RedisCache, Key, p, CacheExpire)
	b.ResponseSuccess()

	msg := fmt.Sprintf("更新各种规则(类型:%v,数值:%v)", p.Type, p.Amount)
	b.NewLog(LogFinance, OpUpdate, msg, data)

}

// @Title 各种规则列表(开店提成，玩家直充提成，提现手续费等)
// @Description 各种规则列表(开店提成，玩家直充提成，提现手续费等)
// @Success 0 {object} []common.CashRule
// @router /params/list-rule [post]
func (b *OperationController) ListRule() {
	cr, err := pc.ListRule()
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cr
	b.ResponseSuccess()
}

// @Title 删除各种规则列表(开店提成，玩家直充提成，提现手续费等)
// @Description 删除各种规则列表(开店提成，玩家直充提成，提现手续费等)
// @Param   type           body   int        true        "类型"
// @Success 0 {string}  状态码
// @router /params/delete-rule [post]
func (b *OperationController) DeleteRule() {
	type Params struct {
		Type int64 `json:"type" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteRule(p.Type)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	Key := fmt.Sprintf("%v%v", KeyRuleType, p.Type)
	SetCache(RedisCache, Key, p, CacheExpire)
	msg := fmt.Sprintf("删除各种规则(ID%v)", p.Type)
	b.NewLog(LogFinance, OpDelete, msg, map[string]interface{}{})
}
